﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using DevExpress.XtraEditors;
using System.IO.Ports;
//using SerialPortHelperLib;
using XChip_Common;
using XChipTool.Enties;
using System.Configuration;
using BinAnalysisHelp;
using AdbService;

namespace XChipTool
{
    public partial class XChip_Reg_Snr : DevExpress.XtraEditors.XtraUserControl
    {

        public SerialPort sPortTemp;
        private bool isRead = false;
        private bool isWrite = false;
        private KeyEventArgs keyEnter = new KeyEventArgs(Keys.Enter);//用来手动触发文本框下发配置
        List<string> listfiltration = new List<string> { "slope", "scale_sigma", "scale_nr" };
        public parameter_exportManager Pe_dal { get; private set; }
        private addressregisterManager aBll;
        private List<addressregister> XChipSnr;
        private List<addressregister> XChipDnr;
        //记录是否使用USB设备读写
        public bool IsUsbOpen = false;
        //记录是否使用I2C设备读写
        public bool m_open = false;
        // 使用服务定位器获取ADB服务
        private IAdbCommandService adbService = ServiceLocator.AdbCommandService;
        public XChip_Reg_Snr()
        {
            InitializeComponent();
        }
        public XChip_Reg_Snr(SerialPort _sPortTemp, addressregisterManager _aBll)
        {
            aBll = _aBll;
            XChipSnr = aBll.GetList(c => c.ChipType == ConfigurationManager.AppSettings["xc151_ChipType"] && (c.Classify == "SNR" ));
            XChipDnr = aBll.GetList(c => c.ChipType == ConfigurationManager.AppSettings["xc151_ChipType"] && (c.Classify == "DNR" ));
            InitializeComponent();
        }

        private void XChip_Reg_Snr_Load(object sender, EventArgs e)
        {
            Task.Run(() => {
            this.Invoke((EventHandler)delegate {
                for (int i = 0; i < XChipSnr.Count; i++)
                {

                    var type =AppHelper.NameTypeToString( XChipSnr[i].NameType);
                    var col = this.Controls.Find(type, true);


                    foreach (var item in col)
                    {
                        if (item is TextEdit)
                        {
                            //声明一个SuerToolTip
                            DevExpress.Utils.SuperToolTip graduationBatchSuperToolTip = new DevExpress.Utils.SuperToolTip();
                            //声明一个ToolTipTitleItem,保存标题
                            DevExpress.Utils.ToolTipTitleItem toolTipTitleItem = new DevExpress.Utils.ToolTipTitleItem();
                            String tooltips = "";

                            if (!string.IsNullOrEmpty(XChipSnr[i].Bit_Wide))
                            {
                                tooltips += $"位宽={XChipSnr[i].Bit_Wide}";
                            }
                            if (!string.IsNullOrEmpty(XChipSnr[i].Bit_Accuracy))
                            {
                                tooltips += $"|精度={XChipSnr[i].Bit_Accuracy}";
                            }
                            //设置标题文字
                            toolTipTitleItem.Text = tooltips;
                            //把标题添加到SuerToolTip
                            graduationBatchSuperToolTip.Items.Add(toolTipTitleItem);
                            //指定控件的SuperTip
                            ((TextEdit)item).SuperTip = graduationBatchSuperToolTip;
                            //正则判断
                            ((TextEdit)item).Properties.Mask.MaskType = DevExpress.XtraEditors.Mask.MaskType.RegEx;
                            ((TextEdit)item).Properties.Mask.EditMask = BitsHelp.GetBitsToMask(XChipSnr[i].Bits, XChipSnr[i].Bit_Wide, XChipSnr.Where(c => c.NameType.ToLower().Contains(type) && c.ControlType == "0").Select(c => c.Bits).ToList());
                        }
                    }
                }
            });
            });
        }

        

        private async void dir_nd_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"dir_nd_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"dir_nd_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), dir_nd_en.Checked);
                SetSNRRegister(model, Val);
            }
        }

        private async void dir_pd_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
             
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"dir_pd_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"dir_pd_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), dir_pd_en.Checked);
                SetSNRRegister(model, Val);
            }
        }

        private async void dir_h_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"dir_h_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"dir_h_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), dir_h_en.Checked);
                SetSNRRegister(model, Val);
            }
        }

        private async void dir_v_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"dir_v_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"dir_v_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), dir_v_en.Checked);
                SetSNRRegister(model, Val);
            }
        }

        private async void block_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"block_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"block_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), block_en.Checked);
                SetSNRRegister(model, Val);
            }
        }

        private async void pixel_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"pixel_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"pixel_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), pixel_en.Checked);
                SetSNRRegister(model, Val);
            }
        }

        private async void snr_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"snr_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"snr_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), snr_en.Checked);
                SetSNRRegister(model, Val);
            }
        }

        private async void inc_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"inc_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"inc_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), inc_en.Checked);
                SetSNRRegister(model, Val);
            }
        }


        private async Task<long> GetSNRRegister(string nameType)
        { 


            if (XChipSnr.Exists(c => c.NameType.ToLower() == nameType.ToLower()))
            {
                long var = await ReadRegisterAsync(XChipSnr.Where(c => c.NameType.ToLower() == nameType.ToLower()).First().Address);
                return var;
            }
            else
            {
                DevExpress.XtraEditors.XtraMessageBox.Show($"未找到{nameType}"); return -1;
            }
        }
        private async void SetSNRRegister(addressregister model, ulong add, bool isCheck = true)
        {
            if (isRead) return;

            bool success = await WriteRegisterAsync(model.Address, add.ToString("X"));

            if (!success)
            {
                Console.WriteLine($"[ADBForm] SetDnsRegister 写入失败 - 地址: {model.Address}, 值: {add:X}");
            }
        }

        private void inc_shift_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(inc_shift.Text)) {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"inc_shift".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"inc_shift".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, inc_shift.Text);
                    if (Convert.ToUInt32(inc_shift.Text, 16)>Val)
                    {
                        inc_shift.Text = Val.ToString("X");
                    }
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void inc_shift_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            inc_shift_KeyDown(sender, keyEnter);
        }

        private void inc_wave_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(inc_wave.Text))
            {
                var nHigh = Convert.ToUInt32(inc_wave.Text, 16);
                if (XChipHelp.XChipSnr.Exists(c => c.NameType.ToLower() == $"inc_wave_h".ToLower()))
                {
                    var model = XChipHelp.XChipSnr.Find(c => c.NameType.ToLower() == $"inc_wave_h".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, inc_wave.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipHelp.XChipSnr.Exists(c => c.NameType.ToLower() == $"inc_wave_l".ToLower()))
                {
                    var model = XChipHelp.XChipSnr.Find(c => c.NameType.ToLower() == $"inc_wave_l".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, inc_wave.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }
        private void inc_wave_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            inc_wave_KeyDown(sender, keyEnter);
        }
        private void slope_k_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(slope_k.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"slope_k".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"slope_k".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, slope_k.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void slope_k_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            slope_k_KeyDown(sender, keyEnter);
        }

        private void slope_b_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(slope_b.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"slope_b".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"slope_b".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, slope_b.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void slope_b_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            slope_b_KeyDown(sender, keyEnter);
        }

        private void offset_k_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(offset_k.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"offset_k".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"offset_k".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, offset_k.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void offset_k_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            offset_k_KeyDown(sender, keyEnter);
        }

        private void offset_b_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(offset_b.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"offset_b".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"offset_b".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, offset_b.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void offset_b_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            offset_b_KeyDown(sender, keyEnter);
        }

        private void scale_sigma_p_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(scale_sigma_p.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"scale_sigma_p".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"scale_sigma_p".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, scale_sigma_p.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void scale_sigma_p_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_sigma_p_KeyDown(sender, keyEnter);
        }

        private void scale_sigma_b_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(scale_sigma_b.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"scale_sigma_b".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"scale_sigma_b".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, scale_sigma_b.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void scale_sigma_b_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_sigma_b_KeyDown(sender, keyEnter);
        }

        private void scale_sigma_d_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(scale_sigma_d.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"scale_sigma_d".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"scale_sigma_d".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, scale_sigma_d.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void scale_sigma_d_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_sigma_d_KeyDown(sender, keyEnter);
        }

        private void weight_center_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(weight_center.Text))
            {
                //下发dnr寄存器
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Gsl5".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Gsl5".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, weight_center.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Gsl6".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Gsl6".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, weight_center.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Gsl7".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Gsl7".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, weight_center.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Gsl8".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Gsl8".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, weight_center.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Gsl9".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Gsl9".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, weight_center.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"weight_center".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"weight_center".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, weight_center.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void weight_center_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            weight_center_KeyDown(sender, keyEnter);
        }

        private void scale_sigma_man_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(scale_sigma_man.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"scale_sigma_man".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"scale_sigma_man".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, scale_sigma_man.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void scale_sigma_man_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_sigma_man_KeyDown(sender, keyEnter);
        }

        private void scale_nr_man_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter && !string.IsNullOrEmpty(scale_nr_man.Text))
            {
                if (XChipSnr.Exists(c => c.NameType.ToLower() == $"scale_nr_man".ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == $"scale_nr_man".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, scale_nr_man.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void scale_nr_man_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_nr_man_KeyDown(sender, keyEnter);
        }

        private async void scale_sigma_man_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"scale_sigma_man_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"scale_sigma_man_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), scale_sigma_man_en.Checked);
                SetSNRRegister(model, Val);
            }
            EnShowHide();
        }

        private async void scale_nr_man_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"scale_nr_man_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"scale_nr_man_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), scale_nr_man_en.Checked);
                SetSNRRegister(model, Val);
            }
            EnShowHide();
        }

        private void scale_sigma_list_0_KeyDown(object sender, KeyEventArgs e)
        {

            if (e.KeyCode == Keys.Enter)
            {
                if (isWrite) return;
                var txtEdit = sender as DevExpress.XtraEditors.TextEdit;
                if (string.IsNullOrEmpty(txtEdit.Text)) return;
                if (XChipSnr.Exists(c => c.NameType.ToLower() == txtEdit.Name.ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == txtEdit.Name.ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
            }
           
        }

        private void scale_sigma_list_0_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_sigma_list_0_KeyDown(sender, keyEnter);
        }

        private void scale_nr_list_0_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                if (isWrite) return;
                var txtEdit = sender as DevExpress.XtraEditors.TextEdit;
                if (string.IsNullOrEmpty(txtEdit.Text)) return;
                if (XChipSnr.Exists(c => c.NameType.ToLower() == txtEdit.Name.ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == txtEdit.Name.ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
            }
            

        }

        private void scale_nr_list_0_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_nr_list_0_KeyDown(sender, keyEnter);
        }

        private void scale_sigma_actv_0_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                if (isWrite) return;
                var txtEdit = sender as DevExpress.XtraEditors.TextEdit;
                if (string.IsNullOrEmpty(txtEdit.Text)) return;
                if (XChipSnr.Exists(c => c.NameType.ToLower() == txtEdit.Name.ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == txtEdit.Name.ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }

        private void scale_sigma_actv_0_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_sigma_actv_0_KeyDown(sender, keyEnter);
        }
        /// <summary>
        /// 获取
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void simpleButton5_Click(object sender, EventArgs e)
        {
            isRead = true;
            WaitBefore.Start("读取中", "正在加载中", 10);
            // 记录开始时间和寄存器计数
            var startTime = DateTime.Now;
            int totalRegisterCount = 0;

            List<string> NameList = new List<string>();

            for (int i = 0; i < XChipSnr.Count; i++)
            {
                if (XChipSnr[i].NameType.Contains("enh_en"))
                {

                }
                var type = AppHelper.NameTypeToString(XChipSnr[i].NameType);
                if (NameList.Exists(c => c.ToLower() == (type)))
                {
                    continue;
                }
                //加上单选框的_en
                if (XChipSnr[i].ControlType == "1")
                {
                    type = XChipSnr[i].NameType;
                }
                var col = Controls_Find(type);

                foreach (var item in col)
                {
                    if (item is TextEdit)
                    {

                        var nList = XChipSnr.Where(c => c.NameType.ToLower().Contains(item.Name.ToString().ToLower()) && c.ControlType == "0").ToList();
                        if (nList.Count == 0)
                        {
                            nList = XChipSnr.Where(c => c.NameType.ToLower().Contains(item.Name.ToString().ToLower()) && c.ControlType == "0").ToList();
                        }
                        if (nList.Count == 1)
                        {
                            // 单个寄存器读取
                            var address = nList[0].Address;
                            totalRegisterCount++;
                            await ReadRegisterAndUpdateTextAsync(address, item as TextEdit, nList[0].Bits, nList[0].Hex);
                        }
                        else
                        {
                            // 多个寄存器组合读取
                            totalRegisterCount += nList.Count;
                            await ReadMultipleRegistersAndUpdateTextAsync(nList, item as TextEdit);
                        }
                    }
                    else if (item is CheckEdit)
                    {
                        var nList = XChipSnr.Where(c => c.NameType.ToLower().Contains(item.Name.ToString().ToLower()) && c.ControlType == "1").ToList();
                        if (nList.Count == 1)
                        {
                            var address = nList[0].Address;
                            totalRegisterCount++;
                            await ReadRegisterAndUpdateCheckAsync(address, item as CheckEdit, nList[0].Bits, nList[0].Hex);
                        }
                    }
                    NameList.Add(item.Name);

                }
            }
            isRead = false;
            WaitBefore.Close();
            EnShowHide();

        }
        private Control[] Controls_Find(string str)
        {
            List<Control> listc = new List<Control>();
            System.Reflection.FieldInfo[] fieldInfo = this.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
            for (int i = 0; i < fieldInfo.Length; i++)
            {
                if (fieldInfo[i].Name.ToLower().Contains(str.ToLower()))
                {
                    listc.AddRange(this.Controls.Find(fieldInfo[i].Name, true));
                }
            }
            return listc.ToArray();
        }

        public async void Get_SlopeOffsetSigmaNr() {
            slope.Text = (await GetSNRRegister("slope")).ToString("X2");
            offset.Text = (await GetSNRRegister("offset_h") + await GetSNRRegister("offset_l")).ToString("X4");
            scale_sigma.Text = (await GetSNRRegister("scale_sigma")).ToString("X2");
            scale_nr.Text = (await GetSNRRegister("scale_nr")).ToString("X2");
            
        }

        private void simpleButton3_Click(object sender, EventArgs e)
        {
            Get_SlopeOffsetSigmaNr();
        }

        private void btn_SaveISPSetting_Click(object sender, EventArgs e)
        {
            //SaveFileDialog sfd = new SaveFileDialog();
            ////设置文件类型 
            //sfd.Filter = "配置文件（*.txt）|*.txt";

            ////设置默认文件类型显示顺序 
            //sfd.FilterIndex = 1;

            ////保存对话框是否记忆上次打开的目录 
            //sfd.RestoreDirectory = true;
            //sfd.FileName = "IQ_Setting_SNR_" + DateTime.Now.ToString("yyyyMMddHHmmss");
            //if (sfd.ShowDialog() == DialogResult.OK)
            //{
            //    SerialSend.isDebug = false;
            //    StringBuilder sb = new StringBuilder();
            //    Pe_dal = new parameter_exportManager();
            //    if (null != Pe_dal)
            //    {
            //        WaitBefore.Start("参数导出", "正在加载中", 60);
            //        //var tempList = Pe_dal.GetList().OrderBy(c => c.SortNum);
            //        var tempList = Pe_dal.GetList(c=> c.Module == "SNR").OrderBy(c => c.SortNum).ToList();
            //        #region 判断是否需要用白天的数据
            //        //var Pe_patch_dal = new parameter_export_patchManager();
            //        //var patchList = Pe_patch_dal.GetList();
            //        //var conditionList = tempList.Select(c => c.ConditionAddr).Distinct().ToList();
            //        //foreach (var item in conditionList)
            //        //{
            //        //    if (SerialSend.ReadRegister(Convert.ToUInt32(item, 16), sPortTemp) == 0)
            //        //    {
            //        //        patchList.RemoveAll(c => c.ConditionAddr == item);
            //        //    }
            //        //}
            //        #endregion
            //        sb.Append("0xffff,0xfef1,\n");
            //        sb.Append("\n");
            //        sb.Append($"//{tempList.First().Module}\n");
            //        foreach (var item in tempList)
            //        {
            //            try
            //            {
            //                sb.Append(string.IsNullOrEmpty(item.PreNote) ? "" : "\n" + item.PreNote + "\n");
            //                sb.Append(string.IsNullOrEmpty(item.addr) ? "" : item.addr);
            //                #region 判断是否需要用白天的数据
            //                if (!string.IsNullOrEmpty(item.ReadAddr))
            //                {
            //                    //if (patchList.Count != 0 && patchList.Select(c => c.ReadAddr).Contains(item.ReadAddr))
            //                    //{
            //                    //    sb.Append($",0x{SerialSend.ReadRegister((Convert.ToUInt32(item.RelationAddr.Trim(), 16)), sPortTemp).ToString("x2")},");
            //                    //}
            //                    //else
            //                    //{
            //                        sb.Append($",0x{SerialSend.ReadRegister((Convert.ToUInt32(item.ReadAddr.Trim(), 16)), sPortTemp).ToString("x2")},");
            //                    //}
            //                }
            //                #endregion
            //                sb.Append(string.IsNullOrEmpty(item.RearNote) ? "" : item.RearNote = item.RearNote.Replace("\\n", "\n").Replace("\\r", "\r"));
            //                sb.Append("\n");
            //            }
            //            catch (Exception ex)
            //            {
            //                WaitBefore.Close();
            //                //setShowMsg(item.RelationAddr);
            //                DevExpress.XtraEditors.XtraMessageBox.Show(ex.Message);
            //                return;
            //            }
            //        }
            //        System.IO.File.WriteAllText(sfd.FileName, sb.ToString());
            //        WaitBefore.Close();
            //        DevExpress.XtraEditors.XtraMessageBox.Show("参数导出完成");
            //    }
            //}
            //SerialSend.isDebug = true;
        }

        private async void weight_s4_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"weight_s4_en".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"weight_s4_en".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), weight_s4_en.Checked);
                SetSNRRegister(model, Val);
            }

        }

        private async void tunning_disp_en_CheckedChanged(object sender, EventArgs e)
        {
            if (isRead) return;

            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"{tunning_en.Name}".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"{tunning_en.Name}".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), tunning_en.Checked);
                SetSNRRegister(model, Val);
            }
            
            Mode_switch.Enabled = tunning_en.Checked;
            Mode_switch.SelectedIndex = 0;

        }

        private async void Mode_switch_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (isWrite) return;
            
            if (XChipSnr.Exists(c => c.NameType.ToLower() == "tunning_branch".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == "tunning_branch".ToLower());
                var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, Mode_switch.SelectedIndex.ToString());
                SetSNRRegister(model, Val);
            }
            if (XChipSnr.Exists(c => c.NameType.ToLower() == $"{tunning_en.Name}".ToLower()))
            {
                var model = XChipSnr.Find(c => c.NameType.ToLower() == $"{tunning_en.Name}".ToLower());
                var Add = await ReadRegisterAsync(model.Address);
                var Val = BitsHelp.SetBitsCheckedToUint(model.Bits, model.Hex, Add.ToString("X2"), tunning_en.Checked);
                SetSNRRegister(model, Val);
            }
        }

        private void scale_sigma_list4_Leave(object sender, EventArgs e)
        {
            if (isWrite) return;
            scale_sigma_list4_KeyDown(sender, keyEnter);
        }

        private void scale_sigma_list4_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                if (isWrite) return;
                var txtEdit = sender as DevExpress.XtraEditors.TextEdit;
                if (string.IsNullOrEmpty(txtEdit.Text)) return;
                //下发dnr寄存器
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Rbsl5".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Rbsl5".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Rbsl6".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Rbsl6".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Rbsl7".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Rbsl7".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Rbsl8".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Rbsl8".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipDnr.Exists(c => c.NameType.ToLower() == "Raw_Rbsl9".ToLower()))
                {
                    var model = XChipDnr.Find(c => c.NameType.ToLower() == "Raw_Rbsl9".ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
                if (XChipSnr.Exists(c => c.NameType.ToLower() == txtEdit.Name.ToLower()))
                {
                    var model = XChipSnr.Find(c => c.NameType.ToLower() == txtEdit.Name.ToLower());
                    var Val = BitsHelp.SetBitsToUint(model.Bits, model.Hex, txtEdit.Text);
                    SetSNRRegister(model, Val);
                }
            }
        }
        private void EnShowHide()
        {
            scale_sigma_man.Enabled = scale_sigma_man_en.Checked;
            scale_nr_man.Enabled = scale_nr_man_en.Checked;
            scale_sigma_list0.Enabled = !scale_sigma_man_en.Checked;
            scale_sigma_list1.Enabled = !scale_sigma_man_en.Checked;
            scale_sigma_list2.Enabled = !scale_sigma_man_en.Checked;
            scale_sigma_list3.Enabled = !scale_sigma_man_en.Checked;
            scale_sigma_list4.Enabled = !scale_sigma_man_en.Checked;
            scale_sigma_list5.Enabled = !scale_sigma_man_en.Checked;
            scale_sigma_list6.Enabled = !scale_sigma_man_en.Checked;
            scale_sigma_list7.Enabled = !scale_sigma_man_en.Checked;
            scale_sigma_list8.Enabled = !scale_sigma_man_en.Checked;

            scale_nr_list0.Enabled = !scale_nr_man_en.Checked;
            scale_nr_list1.Enabled = !scale_nr_man_en.Checked;
            scale_nr_list2.Enabled = !scale_nr_man_en.Checked;
            scale_nr_list3.Enabled = !scale_nr_man_en.Checked;
            scale_nr_list4.Enabled = !scale_nr_man_en.Checked;
            scale_nr_list5.Enabled = !scale_nr_man_en.Checked;
            scale_nr_list6.Enabled = !scale_nr_man_en.Checked;
            scale_nr_list7.Enabled = !scale_nr_man_en.Checked;
            scale_nr_list8.Enabled = !scale_nr_man_en.Checked;


        }

        /// <summary>
        /// 异步读取单个寄存器并更新文本框
        /// </summary>
        private async Task ReadRegisterAndUpdateTextAsync(string address, TextEdit textEdit, string bits, string hex)
        {
            try
            {
                Console.WriteLine($"[ADBForm] 开始读取寄存器: {address}");

                // 发送读取命令
                string adbCommand = $"adb shell setprop vendor.extcamera.xxw.ispregctrl \"0,{address},0,0\"";
                adbService.ExecuteAdbCommandAsync(adbCommand, $"读操作 - 地址:{address}");

                // 等待命令执行
                await Task.Delay(10);

                // 获取寄存器值
                var record = await Task.Run(() => LogcatDataManager.FindByRegisterAddressSync(address, "Read", 500));

                if (record != null && !string.IsNullOrEmpty(record.Values) && record.Values != "0")
                {
                    string processedValue = record.Values;
                    if (processedValue.StartsWith("0x"))
                    {
                        processedValue = processedValue.Substring(2);
                    }

                    Console.WriteLine($"[ADBForm] 成功读取寄存器 {address} 值: {processedValue}");

                    // 处理位操作
                    string displayValue;
                    if (processedValue != "0")
                    {
                        var uintValue = BitsHelp.GetBitsToUint(bits, hex, processedValue);
                        displayValue = uintValue.ToString("X");
                        Console.WriteLine($"[ADBForm] 寄存器 {address} Bits处理后值: {displayValue} (bits:{bits}, hex:{hex})");
                    }
                    else
                    {
                        displayValue = "0";
                    }

                    // 更新UI
                    UpdateTextEdit(textEdit, displayValue);
                }
                else
                {
                    Console.WriteLine($"[ADBForm] 读取寄存器 {address} 失败，值为空或0，使用默认值0");
                    UpdateTextEdit(textEdit, "0");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[ADBForm] 读取寄存器 {address} 异常: {ex.Message}");
                UpdateTextEdit(textEdit, "错误");
            }
        }

        /// <summary>
        /// 异步读取多个寄存器并组合更新文本框
        /// </summary>
        private async Task ReadMultipleRegistersAndUpdateTextAsync(List<addressregister> nList, TextEdit textEdit)
        {
            try
            {
                Console.WriteLine($"[ADBForm] 开始读取多个寄存器，数量: {nList.Count}");

                string combinedValue = string.Empty;

                // 按预定义的优先级顺序读取寄存器
                var priorityOrder = new[] { "_h", "_m0", "_m1", "_m2", "_m3", "_l" };

                foreach (var priority in priorityOrder)
                {
                    addressregister register = FindRegisterByPriority(nList, priority);

                    if (register != null)
                    {
                        Console.WriteLine($"[ADBForm] 读取优先级 '{priority}' 的寄存器: {register.NameType} ({register.Address})");

                        // 发送读取命令
                        string adbCommand = $"adb shell setprop vendor.extcamera.xxw.ispregctrl \"0,{register.Address},0,0\"";
                        adbService.ExecuteAdbCommandAsync(adbCommand, $"读操作 - 地址:{register.Address}");

                        // 等待命令执行
                        await Task.Delay(10);

                        // 获取寄存器值
                        var record = await Task.Run(() => LogcatDataManager.FindByRegisterAddressSync(register.Address, "Read", 500));

                        if (record != null && !string.IsNullOrEmpty(record.Values) && record.Values != "0")
                        {
                            string processedValue = record.Values;
                            if (processedValue.StartsWith("0x"))
                            {
                                processedValue = processedValue.Substring(2);
                            }

                            combinedValue += processedValue.PadLeft(2, '0');
                            Console.WriteLine($"[ADBForm] 成功读取 {register.Address}，当前组合值: {combinedValue}");
                        }
                        else
                        {
                            combinedValue += "00";
                            Console.WriteLine($"[ADBForm] 读取 {register.Address} 失败，使用默认值00，当前组合值: {combinedValue}");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"[ADBForm] 未找到包含 '{priority}' 的寄存器");
                    }
                }

                Console.WriteLine($"[ADBForm] 最终组合值: {combinedValue}");

                // 更新UI
                UpdateTextEdit(textEdit, combinedValue);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[ADBForm] 读取多个寄存器失败: {ex.Message}");
                UpdateTextEdit(textEdit, "错误");
            }
        }

        /// <summary>
        /// 根据优先级查找寄存器
        /// </summary>
        private addressregister FindRegisterByPriority(List<addressregister> nList, string priority)
        {
            if (priority == "_l")
            {
                // 特殊处理 _l 寄存器
                if (nList.Exists(c => c.NameType.ToLower().Contains("_l")))
                {
                    // 首先查找以 "_l" 结尾的寄存器
                    var exactMatch = nList.Find(c => c.NameType.ToLower().EndsWith("_l"));
                    if (exactMatch != null)
                    {
                        Console.WriteLine($"[ADBForm] 找到以 '_l' 结尾的寄存器: {exactMatch.NameType}");
                        return exactMatch;
                    }
                    else
                    {
                        // 如果没有以 "_l" 结尾的，则使用最后一个包含 "_l" 的寄存器
                        var containsMatch = nList.Last(c => c.NameType.ToLower().Contains("_l"));
                        Console.WriteLine($"[ADBForm] 找到包含 '_l' 的寄存器: {containsMatch.NameType}");
                        return containsMatch;
                    }
                }
            }
            else
            {
                // 其他寄存器正常处理
                var register = nList.Find(c => c.NameType.ToLower().Contains(priority));
                if (register != null)
                {
                    Console.WriteLine($"[ADBForm] 找到包含 '{priority}' 的寄存器: {register.NameType}");
                    return register;
                }
            }

            return null;
        }

        /// <summary>
        /// 更新文本框的辅助方法
        /// </summary>
        private void UpdateTextEdit(TextEdit textEdit, string value)
        {
            if (textEdit.InvokeRequired)
            {
                textEdit.Invoke(new Action(() =>
                {
                    textEdit.Text = value;
                    Console.WriteLine($"[ADBForm] UI已更新，文本框值: {value}");
                }));
            }
            else
            {
                textEdit.Text = value;
                Console.WriteLine($"[ADBForm] UI已更新，文本框值: {value}");
            }
        }

        /// <summary>
        /// 异步读取寄存器并更新复选框
        /// </summary>
        private async Task ReadRegisterAndUpdateCheckAsync(string address, CheckEdit checkEdit, string bits, string hex)
        {
            try
            {
                Console.WriteLine($"[ADBForm] 开始读取寄存器并更新复选框: {address}");

                string adbCommand = $"adb shell setprop vendor.extcamera.xxw.ispregctrl \"0,{address},0,0\"";
                adbService.ExecuteAdbCommandAsync(adbCommand, $"读操作 - 地址:{address}");

                // 等待命令执行
                await Task.Delay(10);

                var record = await Task.Run(() => LogcatDataManager.FindByRegisterAddressSync(address, "Read", 500));

                bool isChecked = false;
                if (!string.IsNullOrEmpty(record.Values) && record.Values != "0")
                {
                    isChecked = BitsHelp.GetBitsCheckedToBool(bits, hex, record.Values) == 0;
                    Console.WriteLine($"[ADBForm] 复选框更新 - 地址:{address}, 值:{record.Values}, 状态:{isChecked}");
                }
                else
                {
                    Console.WriteLine($"[ADBForm] 复选框更新 - 地址:{address}, 值无效, 状态:false");
                }

                // 更新UI
                if (checkEdit.InvokeRequired)
                {
                    checkEdit.Invoke(new Action(() => checkEdit.Checked = isChecked));
                }
                else
                {
                    checkEdit.Checked = isChecked;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[ADBForm] 读取寄存器 {address} 更新复选框失败: {ex.Message}");
                if (checkEdit.InvokeRequired)
                {
                    checkEdit.Invoke(new Action(() => checkEdit.Checked = false));
                }
                else
                {
                    checkEdit.Checked = false;
                }
            }
        }

        /// <summary>
        /// 异步读取单个寄存器返回值
        /// </summary>
        private async Task<long> ReadRegisterAsync(string address)
        {
            try
            {
                Console.WriteLine($"[ADBForm] 开始读取寄存器: {address}");
                // 发送读取命令
                string adbCommand = $"adb shell setprop vendor.extcamera.xxw.ispregctrl \"0,{address},0,0\"";
                adbService.ExecuteAdbCommandAsync(adbCommand, $"读操作 - 地址:{address}");

                // 等待命令执行
                await Task.Delay(10);

                // 获取寄存器值
                var record = await Task.Run(() => LogcatDataManager.FindByRegisterAddressSync(address, "Read", 500));

                if (record != null && !string.IsNullOrEmpty(record.Values) && record.Values != "0")
                {
                    return Convert.ToInt32(record.Values, 16);
                }
                else
                {
                    Console.WriteLine($"[ADBForm] 读取寄存器 {address} 失败，值为空或0，使用默认值0");
                    return 0;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[ADBForm] 读取寄存器 {address} 异常: {ex.Message}");
                return 0;
            }
        }
        /// <summary>
        /// 异步写入单个寄存器，在值不匹配时自动重试一次
        /// </summary>
        private async Task<bool> WriteRegisterAsync(string address, string value)
        {
            int maxRetries = 1; // 值不匹配时最多重试一次
            int retryCount = 0;

            while (retryCount <= maxRetries)
            {
                try
                {
                    if (retryCount > 0)
                    {
                        Console.WriteLine($"[ADBForm] 第 {retryCount} 次重试写入寄存器: {address} 值: {value}");
                    }
                    else
                    {
                        Console.WriteLine($"[ADBForm] 开始写入寄存器: {address} 值: {value}");
                    }

                    // 处理位操作（如果有）
                    string processedValue = value;

                    // 确保值是十六进制格式（不带0x前缀）
                    if (processedValue.StartsWith("0x"))
                    {
                        processedValue = processedValue.Substring(2);
                    }

                    // 发送写入命令
                    string adbCommand = $"adb shell setprop vendor.extcamera.xxw.ispregctrl \"1,{address},{processedValue},0\"";
                    adbService.ExecuteAdbCommandAsync(adbCommand, $"写操作 - 地址:{address} 值:{processedValue}");

                    // 等待命令执行
                    await Task.Delay(10);

                    // 验证写入是否成功 - 等待写入记录出现
                    var writeRecord = await Task.Run(() => LogcatDataManager.FindByRegisterAddressSync(address, "Write", 500));

                    if (writeRecord != null && !string.IsNullOrEmpty(writeRecord.Values))
                    {
                        string actualValue = writeRecord.Values;
                        if (actualValue.StartsWith("0x"))
                        {
                            actualValue = actualValue.Substring(2);
                        }

                        // 比较写入的值是否匹配
                        bool success = string.Equals(actualValue, processedValue, StringComparison.OrdinalIgnoreCase);

                        if (success)
                        {
                            Console.WriteLine($"[ADBForm] 成功写入寄存器 {address} 值: {processedValue}");
                            return true;
                        }
                        else
                        {
                            Console.WriteLine($"[ADBForm] 写入寄存器 {address} 值不匹配，期望: {processedValue}，实际: {actualValue}");

                            // 如果不匹配且还有重试次数，则继续重试
                            if (retryCount < maxRetries)
                            {
                                retryCount++;
                                Console.WriteLine($"[ADBForm] 准备重试写入...");
                                continue; // 直接进入下一次循环，重新发送命令
                            }
                            else
                            {
                                Console.WriteLine($"[ADBForm] 写入寄存器 {address} 重试次数已用完，仍然不匹配");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        Console.WriteLine($"[ADBForm] 写入寄存器 {address} 失败，未找到写入确认记录");

                        // 如果未找到记录且还有重试次数，则重试
                        if (retryCount < maxRetries)
                        {
                            retryCount++;
                            Console.WriteLine($"[ADBForm] 准备重试写入...");
                            continue;
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"[ADBForm] 写入寄存器 {address} 异常: {ex.Message}");

                    // 如果异常且还有重试次数，则重试
                    if (retryCount < maxRetries)
                    {
                        retryCount++;
                        Console.WriteLine($"[ADBForm] 准备重试写入...");
                        await Task.Delay(10); // 异常后稍作延迟再重试
                        continue;
                    }
                    else
                    {
                        return false;
                    }
                }
            }

            return false; // 理论上不会执行到这里
        }


    }



}
